home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 207_01 / checkb.c < prev    next >
Text File  |  1980-01-01  |  14KB  |  502 lines
  1. /*  checkb.c -- 3rd source file for check register program                   */
  2.  
  3. /*  copyright (c) 1986 by Jim Woolley and WoolleyWare, San Jose, CA          */
  4.  
  5. /*  vers. 1.0, 12/85 thru 5/86
  6.  */
  7.  
  8. /*  this file contains:
  9.  *      display( i)
  10.  *      putrecord( i)
  11.  *      update( i)
  12.  *      newbalance( i)
  13.  *      newentry( i)
  14.  *      clrscr()
  15.  *      clreol( c)
  16.  *      dellin( r)
  17.  *      inslin( r)
  18.  *      putscr( z)
  19.  *      godown( c)
  20.  *      shodown()
  21.  *      goup( c)
  22.  *      goright( c)
  23.  *      goleft( c)
  24.  *      gonext()
  25.  *      goprior()
  26.  *      gobottom()
  27.  *      gotop()
  28.  *      goupdown( c)
  29.  */
  30.  
  31. #include    "a:checks.h"
  32.  
  33. display( i)                             /*  display entries i thru Last      */
  34. int i;
  35. {
  36.     char c;
  37.     int firstrow, lastrow;
  38.  
  39.     c = 0;
  40.     i = max( i, First);
  41.     while ( i <= Last)
  42.     {
  43.         if ( !c && kbhit())             /*  look ahead for vertical motion   */
  44.         {
  45.             if ((( c = getchar()) == CTRLR && First) ||
  46.                 ( c == CTRLC && ( First + LAST) <= Maxentry))
  47.                 break;
  48.             if ( !( *Lindel) && (       /*  if no line delete control and    */
  49.                 ( c == CTRLX && Recno >= ( Last - 1) &&
  50.                     ( Last - First + HEAD) == ( ROWS - 1)) ||
  51.                 ( c == CTRLZ && First < Last)
  52.                 ))
  53.                 break;
  54.             if ( !( *Linins) &&         /*  if no line insert control and    */
  55.                 First && (( c == CTRLE && Recno == First) || c == CTRLW))
  56.                 break;
  57.         }
  58.         putrecord( i++);
  59.     }
  60.     i = Last + 1;
  61.     firstrow = First - HEAD;
  62.     lastrow = firstrow + ROWS;
  63.     while ( i < lastrow)
  64.     {
  65.         cursorto(( i - firstrow), 0);
  66.         clreol( 0);                     /*  clear bottom of screen           */
  67.         ++i;
  68.     }
  69.     if ( c)                             /*  restore keyboard char            */
  70.         ungetch( c);
  71. }
  72.  
  73. putrecord( i)                           /*  display Entry[ i]                */
  74. int i;
  75. {
  76.     char c, *p, s[ 10];
  77.     int count;
  78.     struct record *e;
  79.  
  80.     e = &Entry[ i];
  81.     cursorto(( i - First + HEAD), 0);
  82.     putdate( &( e->date));
  83.     count = PAYEESIZE - 1 - strlen( p = e->payee);
  84.     puts( p);
  85.     while ( count--)
  86.         putchar( PAYEEFILL);
  87.     putchar( ' ');
  88.     putchar( e->category & 0x7f);
  89.     putchar( ' ');
  90.     putmoney( &( e->amount));
  91.     puts( e->deposit ? "DEP " : DEPCLRFIL);
  92.     puts( e->clear ? "CLR " : DEPCLRFIL);
  93.     putmoney( &Balance[ i]);
  94. }
  95.  
  96. update( i)                              /*  update balance for entry >= i    */
  97. int i;
  98. {
  99.     int firstrow;
  100.  
  101.     firstrow = First - HEAD;
  102.     while ( i <= Maxentry)
  103.     {
  104.         newbalance( i);
  105.         if ( First <= i && i <= Last)
  106.         {
  107.             cursorto(( i - firstrow), BALCOL);
  108.             putmoney( &Balance[ i]);
  109.         }
  110.         ++i;
  111.     }
  112. }
  113.  
  114. newbalance( i)                          /*  update balance for entry i       */
  115. int i;
  116. {
  117.     struct record *e;
  118.     struct money m, *p;
  119.  
  120.     if ( i)
  121.         p = &Balance[ i - 1];
  122.     else
  123.     {
  124.         m.dollar = 0;
  125.         m.cent = 0;
  126.         p = &m;
  127.     }
  128.     e = &Entry[ i];
  129.     addmoney( &Balance[ i], p, &( e->amount), e->deposit);
  130. }
  131.  
  132. newentry( i)                            /*  create and initialize entry i    */
  133. int i;
  134. {
  135.     struct record *en, *ep;
  136.  
  137.     en = &Entry[ i];
  138.     if ( Today.yy)
  139.     {
  140.         en->date.mm = Today.mm;
  141.         en->date.dd = Today.dd;
  142.         en->date.yy = Today.yy;
  143.     }
  144.     else if ( i)
  145.     {
  146.         ep = &Entry[ i - 1];
  147.         en->date.mm = ep->date.mm;
  148.         en->date.dd = ep->date.dd;
  149.         en->date.yy = ep->date.yy;
  150.     }
  151.     en->payee[ 0] = '\0';
  152.     en->category = DEFCAT;
  153.     en->amount.dollar = 0;
  154.     en->amount.cent = 0;
  155.     en->deposit = FALSE;
  156.     en->clear = FALSE;
  157.     newbalance( i);
  158.     Modified = TRUE;
  159. }
  160.  
  161. clrscr()                                /*  clear screen and home cursor     */
  162. {
  163.     int i;
  164.  
  165.     if ( *Trmini)
  166.         putscr( Trmini);
  167.     else
  168.     {
  169.         cursorto(( ROWS - 1), 0);
  170.         for ( i = ROWS; i; --i)
  171.             putchar( '\n');
  172.     }
  173.     cursorto( 0, 0);
  174. }
  175.  
  176. clreol( c)                              /*  clear column c to end-of-line    */
  177. int c;                                  /*  0 is left edge                   */
  178. {                                       /*  cursor must be set to column c   */
  179.     if ( *Eraeol)
  180.         putscr( Eraeol);
  181.     else for ( ; c < COLS; ++c)
  182.         putchar( ' ');
  183. }
  184.  
  185. dellin( r)                              /*  delete line at row r             */
  186. int r;                                  /*  move remaining lines up          */
  187. {                                       /*  display new last line            */
  188.     if ( lindel( r))
  189.         display( First + LAST);
  190.     else display( First + r - HEAD);
  191. }
  192.  
  193. lindel( r)                              /*  if *Lindel != 0,                 */
  194. int r;                                  /*  delete line at row r             */
  195. {                                       /*  move remaining lines up          */
  196.                                         /*  return TRUE; else, return FALSE  */
  197.                                         /*  final cursor pos. indeterminate  */
  198.     if ( *Lindel)
  199.     {
  200.         if ( *Lindel == 255)
  201.         {
  202.             puts( "\033[");             /*  special for VT100                */
  203.             printd( r + 1);
  204.             putchar( 'r');
  205.             cursorto(( ROWS - 1), 0);
  206.             puts( "\033D\033[1r");
  207.         }
  208.         else
  209.         {
  210.             cursorto( r, 0);
  211.             putscr( Lindel);
  212.         }
  213.         return ( TRUE);
  214.     }
  215.     return ( FALSE);
  216. }
  217.  
  218. inslin( r)                              /*  insert blank line at row r       */
  219. int r;                                  /*  move existing lines down         */
  220. {                                       /*  putrecord at row r               */
  221.     if ( linins( r))
  222.         putrecord( First + r - HEAD);
  223.     else display( First + r - HEAD);
  224. }
  225.  
  226. linins( r)                              /*  if *Linins != 0,                 */
  227. int r;                                  /*  insert blank line at row r       */
  228. {                                       /*  move existing lines down         */
  229.                                         /*  position cursor at ( r, 0)       */
  230.                                         /*  return TRUE; else, return FALSE  */
  231.     if ( *Linins)
  232.     {
  233.         if ( *Linins == 255)
  234.         {
  235.             puts( "\033[");             /*  special for VT100                */
  236.             printd( r + 1);
  237.             putchar( 'r');
  238.             cursorto( r, 0);
  239.             puts( "\033M\033[1r");
  240.             cursorto( r, 0);
  241.         }
  242.         else
  243.         {
  244.             cursorto( r, 0);
  245.             putscr( Linins);
  246.         }
  247.         return ( TRUE);
  248.     }
  249.     return ( FALSE);
  250. }
  251.  
  252. putscr( z)                              /*  send screen control chars        */
  253. char *z;                                /*  first char is count of chars     */
  254. {
  255.     char c;
  256.  
  257.     for ( c = *z++; c; --c)
  258.         putchar( *z++);
  259. }
  260.  
  261. godown( c)                              /*  go down one entry                */
  262. char c;
  263. {
  264.     if ( c == CTRLZ)
  265.     {
  266.         if ( Last <= First)
  267.             return;
  268.         ++First;                        /*  scroll up                        */
  269.         Recno = max( Recno, First);
  270.         Last = min(( Last + 1), Maxentry);
  271.         shodown();
  272.         return;
  273.     }
  274.     if ( ++Recno > ( Last - 1))         /*  at next to last on screen?       */
  275.     {
  276.         if ( Recno > Maxentry)          /*  at Maxentry?                     */
  277.         {
  278.             Recno = Maxentry + 1;
  279.             Field = 0;
  280.             if ( c == '\r')             /*  assume new entry desired         */
  281.             {
  282.                 if ( Maxentry < ( ENTRYSIZE - 1))
  283.                 {
  284.                     newentry( ++Maxentry);
  285.                     putrecord( Last = Maxentry);
  286.                     Today.yy = 0;       /*  use previous